#ifndef __WIZ_BNF_PARSER_PREDEFINED_HPP__SHANHAOBO_19800429__
#define __WIZ_BNF_PARSER_PREDEFINED_HPP__SHANHAOBO_19800429__

#include "./WizBNFParserCharAlpha.hpp"
#include "./WizBNFParserCharAny.hpp"
#include "./WizBNFParserCharCheck.hpp"
#include "./WizBNFParserCharRange.hpp"
#include "./WizBNFParserCharSpace.hpp"

#include "./WizBNFParserInteger.hpp"
#include "./WizBNFParserReal.hpp"
#include "./WizBNFParserString.hpp"


#include "./WizBNFParserAlternative.hpp"
#include "./WizBNFParserKleeneStar.hpp"
#include "./WizBNFParserSequence.hpp"
#include "./WizBNFParserPositive.hpp"


namespace Wiz
{
    namespace BNF
    {
        namespace Parser
        {
            namespace Predef
            {
                template <class CharT>
                WIZ_INLINE ::Wiz::BNF::Parser::String::Type<CharT const*>
                    StrCheck(CharT const* Str)
                {
                    return ::Wiz::BNF::Parser::String::Type<CharT const*>(Str);
                }

                template <class CharT>
                WIZ_INLINE ::Wiz::BNF::Parser::String::Type<CharT *>
                    StrCheck(CharT * Str)
                {
                    return ::Wiz::BNF::Parser::String::Type<CharT *>(Str);
                }

                ::Wiz::BNF::Parser::Real::Type<::Wiz::Real64::Type, ::Wiz::BNF::Parser::Policies::Real::Type<::Wiz::Real64::Type>> const
                    RealNumber = ::Wiz::BNF::Parser::Real::Type<::Wiz::Real64::Type, ::Wiz::BNF::Parser::Policies::Real::Type<::Wiz::Real64::Type>>();

                ::Wiz::BNF::Parser::Real::Type<::Wiz::Real64::Type, ::Wiz::BNF::Parser::Policies::StrictReal::Type<::Wiz::Real64::Type>> const
                    FloatNumber = ::Wiz::BNF::Parser::Real::Type<::Wiz::Real64::Type, ::Wiz::BNF::Parser::Policies::StrictReal::Type<::Wiz::Real64::Type>>();

                ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 10, 1, -1> const
                    UDecimal = ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 10, 1, -1>();
                ::Wiz::BNF::Parser::Integer::Signal::Type<::Wiz::Int::Type, 10, 1, -1> const
                    Decimal = ::Wiz::BNF::Parser::Integer::Signal::Type<::Wiz::Int::Type, 10, 1, -1>();
                ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 2, 1, -1> const
                    Binary = ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 2, 1, -1>();
                ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 8, 1, -1> const
                    Octal = ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 8, 1, -1>();
                ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 16, 1, -1> const
                    Hexadecimal = ::Wiz::BNF::Parser::Integer::Unsignal::Type<::Wiz::UInt::Type, 16, 1, -1>();

                ::Wiz::BNF::Parser::Char::Space::Type const SpaceChar = ::Wiz::BNF::Parser::Char::Space::Type();

                template <class CharT>
                WIZ_INLINE ::Wiz::BNF::Parser::Char::Range::Type<CharT>
                    CharRange(CharT const& Frst, CharT const& Lst)
                {
                    return ::Wiz::BNF::Parser::Char::Range::Type<CharT>(Frst, Lst);
                }

                template <class CharT>
                WIZ_INLINE ::Wiz::BNF::Parser::Char::Check::Type<CharT>
                    CharCheck(CharT const& Chr)
                {
                    return ::Wiz::BNF::Parser::Char::Check::Type<CharT>(Chr);
                }

                ::Wiz::BNF::Parser::Char::Any::Type const AnyChar = ::Wiz::BNF::Parser::Char::Any::Type();

                ::Wiz::BNF::Parser::Char::Alpha::Type const AlphaChar = ::Wiz::BNF::Parser::Char::Alpha::Type();

                //////////////////////////////////////////////////////////////////////////
                //////////////////////////////////////////////////////////////////////////

                template <typename S>
                WIZ_INLINE ::Wiz::BNF::Parser::KleeneStar::Type<S>
                    KleeneStar(::Wiz::BNF::Parser::Type<S> const& Sbjct)
                {
                    return ::Wiz::BNF::Parser::KleeneStar::Type<S>(Sbjct.Derived());
                }

                template <typename LeftT, typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Alternative::Type<LeftT, RightT>
                    Alternative(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Alternative::Type<LeftT, RightT>(Lft.Derived(), Rght.Derived());
                }

                template <typename S>
                WIZ_INLINE ::Wiz::BNF::Parser::Positive::Type<S>
                    Positive(::Wiz::BNF::Parser::Type<S> const& Sbjct)
                {
                    return ::Wiz::BNF::Parser::Positive::Type<S>(Sbjct.Derived());
                }

                template <typename LeftT, typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<LeftT, RightT>
                    Sequence(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<LeftT, RightT>(Lft.Derived(), Rght.Derived());
                }

                template <typename LeftT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::Char::Check::Type<::Wiz::Char::Type>>
                    Sequence(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::Char::Type Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::Char::Check::Type<::Wiz::Char::Type>>(Lft.Derived(), Rght);
                }

                template <typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::Char::Check::Type<::Wiz::Char::Type>, RightT>
                    Sequence(::Wiz::Char::Type Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::Char::Check::Type<::Wiz::Char::Type>, RightT>(Lft, Rght.Derived());
                }

                template <typename LeftT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::String::Type<::Wiz::Char::Type const*>>
                    Sequence(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::Char::Type const* Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::String::Type<::Wiz::Char::Type const*>>(Lft.Derived(), Rght);
                }

                template <typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::String::Type<::Wiz::Char::Type const*>, RightT>
                    Sequence(::Wiz::Char::Type const* Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::String::Type<::Wiz::Char::Type const*>, RightT>(Lft, Rght.Derived());
                }

                template <typename LeftT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::Char::Check::Type<::Wiz::WChar::Type>>
                    Sequence(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::WChar::Type Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::Char::Check::Type<::Wiz::WChar::Type>>(Lft.Derived(), Rght);
                }

                template <typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::Char::Check::Type<::Wiz::WChar::Type>, RightT>
                    Sequence(::Wiz::WChar::Type Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::Char::Check::Type<::Wiz::WChar::Type>, RightT>(Lft, Rght.Derived());
                }

                template <typename LeftT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::String::Type<::Wiz::WChar::Type const*>>
                    Sequence(::Wiz::BNF::Parser::Type<LeftT> const& Lft, ::Wiz::WChar::Type const* Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<LeftT, ::Wiz::BNF::Parser::String::Type<::Wiz::WChar::Type const*>>(Lft.Derived(), Rght);
                }

                template <typename RightT>
                WIZ_INLINE ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::String::Type<::Wiz::WChar::Type const*>, RightT>
                    Sequence(::Wiz::WChar::Type const* Lft, ::Wiz::BNF::Parser::Type<RightT> const& Rght)
                {
                    return ::Wiz::BNF::Parser::Sequence::Type<::Wiz::BNF::Parser::String::Type<::Wiz::WChar::Type const*>, RightT>(Lft, Rght.Derived());
                }

            } /// end of namespace Predef
        } /// end of namespace Parser
    } /// end of namespace BNF
} /// end of namespace Wiz

#endif /*__WIZ_BNF_PARSER_PREDEFINED_HPP__SHANHAOBO_19800429__*/

